﻿#include <iostream>
using namespace std;

class A
{
public:
	//普通构造
	A(int a1)
		:_a1(a1)
	{
		cout << "A(int a1)" << endl;
	}
	//构造重载
	A(int a1, int a2)
		:_a1(a1)
		,_a2(a2)
	{
		cout << "A(int a1, int a2)" << endl;
	}
	//拷贝构造
	A(const A& a)
		:_a1(a._a1)
		, _a2(a._a2)
	{
		cout << "A(const A& a)" << endl;
	}

	void Print() const
	{
		cout << _a1 << " " << _a2 << endl;
	}

	int Get() const
	{
		return _a1 + _a2;
	}

private:
	int _a1 = -1;
	int _a2 = -1;
};

class Stack
{
public:
	Stack(int n = 4)
		:_a((A*)malloc(sizeof(A)* n))
		, _capacity(n)
		,_top(0)
	{}

	void Push(const A& a)
	{
		_a[_top++] = a;
	}

	~Stack()
	{
		free(_a);
		_a = nullptr;
		_capacity = _top = 0;
	}

private:
	A* _a;
	size_t _capacity;
	size_t _top;
};

int main()
{
	Stack st;
	//Push的参数加上 const 的原因就是传过去的都是临时对象的引用
	//像这样入栈是不是很方便
	st.Push({ 1,1 });
	st.Push({ 2,2 });
	st.Push({ 3,3 });

	return 0;
}

//
//
//class B
//{
//public:
//	B(const A& a)
//		:_b(a.Get())
//	{
//		cout << "B(const A& a)" << endl;
//	}
//
//private:
//	int _b = 0;
//};
//
//int main()
//{
//	A aa1 = { 1,1 };
//	B bb1 = aa1;
//
//	return 0;
//}


//int main()
//{
//	A aa1 = { 1,1 };//由{1,1}作为参数直接对aa1进行构造
//	aa1.Print();
//
//	const A& ra = { 1,1 };//ra引用的是由{1,1}构造的临时对象
//	ra.Print();
//
//	return 0;
//}


//int main()
//{
//	//1构造⼀个A的临时对象，再用这个临时对象拷贝构造aa1
//	//编译器遇到连续构造+拷贝构造->优化为直接构造
//	A aa1 = 1;
//	aa1.Print();
//
//	const A& r = 1;//临时对象具有常性
//
//	double a = 9.9;//内置类型转换也是临时对象
//	const int& b = a;//因此引用临时对象就要加const
//	
//	return 0;
//}


//class A
//{
//public:
//	A(int a)
//		:_a1(a)
//		,_a2(_a1)
//	{}
//	void Print() {
//		cout << _a1 << " " << _a2 << endl;
//	}
//private:
//	int _a2 = 2;
//	int _a1 = 2;
//};
//
//int main()
//{
//	A aa(1);
//	aa.Print();
//}


//typedef int STDataType;
//class Stack
//{
//public:
//	Stack(int n)
//		:_a((STDataType*)malloc(sizeof(STDataType)*n))
//		,_capacity(n)
//		,_top(0)
//	{}
//
//	~Stack()
//	{
//		free(_a);
//		_a = nullptr;
//		_capacity = _top = 0;
//	}
//
//private:
//	STDataType* _a;
//	size_t _capacity;
//	size_t _top;
//};
//
//class MyQueue
//{
//public:
//	
//private:
//	哪怕 Stack 没有默认构造也可以在定义时给缺省值
//	Stack _pushst = 4;
//	Stack _pophst = 4;
//};
//
//int main()
//{
//	MyQueue q1;
//
//	return 0;
//}

//class Date
//{
//public:
//	Date(int year = 2, int month = 2, int day = 2)
//		:_year(year)
//		, _month(month)
//	{}
//
//private:
//	//注意这里不是初始化，这里给的是缺省值，这个缺省值是给初始化列表的
//	//如果初始化列表没有显示初始化，默认就会用这个缺省值初始化
//	int _year = 1;
//	int _month = 1;
//	int _day = 1;
//	// const 类型成员变量也可以在声明的时候给。
//	const int n = 1;
//};
//
//int main()
//{
//	Date d1;
//
//	return 0;
//}